import random
import sys
import string
import numpy as NP
'''
La funzione sqare genera un data set con i punti dispersi gaussianamente
sugli angoli di un quadrato i cui vertici hanno coordinate:
Ax , Ay =  1,1	 
Bx , By =  1,6	 
Cx , Cy =  6,6 
Dx , Dy =  6,1	 
'''

class data():
	
	def __init__(self):
		
		self.x = 0
		self.y = 0
		
	def fill(self,mu1,mu2,sigma):
		self.x = random.gauss(mu1,sigma)
		self.y = random.gauss(mu2,sigma)
		
		
	def printData(self):
		
		print "(",self.x,",",self.y,")"
		
#~ n =        input("Numero di punti per gruppo:----------->")
#~ g =        input("Numero di gruppi:--------------------->")
sigma =            input("Dispersione dei punti (sigma):-------->")
fileName = raw_input("Nome file di output:------------------>")
tipo = input(" 1 square , 2 pentagon , 3 doppio ,4 nDim:------------------>")

def square(n,g):
	'''
	Crea un data set quadrato
	'''
	
	### Decommentare se si vuole scegliere i vertici manualmente
	
	#~ Ax , Ay =  input("Ax:"),input("Ay:")	 
	#~ Bx , By =  input("Bx:"),input("By:")	 
	#~ Cx , Cy =  input("Cx:"),input("Cy:")	 
	#~ Dx , Dy =  input("Dx:"),input("Dy:")
	
	## ----------------------------------------------------------
	
	### Commentare se si e' scelto vertici manuali---------------
	
	Ax , Ay =  1,1	 
	Bx , By =  1,6	 
	Cx , Cy =  6,6 
	Dx , Dy =  6,1	
	 
	##-----------------------------------------------------------
	
	vecX = range(g)
	for i in range(g):
		vecX[i] = range(n)

	outFile = open(fileName , 'w')
	
	for j in range(n):
		# vertice (Ax , Ay)
		vecX[0][j] = data()
		vecX[0][j].fill(Ax,Ay,sigma)
		 
		# vertice (Bx , By)
		vecX[1][j] = data()
		vecX[1][j].fill(Bx , By,sigma)
		
		# vertice (Cx , Cy)
		vecX[2][j] = data()
		vecX[2][j].fill(Cx , Cy,sigma)
		
		# vertice (Dx , Dy)
		vecX[3][j] = data()
		vecX[3][j].fill(Dx , Dy,sigma)
	
	### Scrive nella prima riga il numero di pattern (righe dopo le prime due)
	outFile.write(str(g*n)+'\n')
	### Scrive nella seconda riga il numeri di variabili (colonne)
	outFile.write(str(2)+'\n')
		
	for i in range(g):
		for j in range(n):	
			outFile.write(str(vecX[i][j].x)+'\t'+str(vecX[i][j].y)+'\n') 
		
	outFile.close()

def pentagon(n,g):
	'''
	Crea un data set pentagonale
	'''
	
	### Decommentare se si vuole scegliere i vertici manualmente
	
	#~ Ax , Ay =  input("Ax:"),input("Ay:")	 
	#~ Bx , By =  input("Bx:"),input("By:")	 
	#~ Cx , Cy =  input("Cx:"),input("Cy:")	 
	#~ Dx , Dy =  input("Dx:"),input("Dy:")
	#~ Fx , Fy =  input("Dx:"),input("Dy:")
	
	## ----------------------------------------------------------
	
	### Commentare se si e' scelto vertici manuali---------------
	
	Ax , Ay =  3,6	 
	Bx , By =  5,4	 
	Cx , Cy =  4,1 
	Dx , Dy =  2,1	
	Fx , Fy =  1,4	
	 
	##-----------------------------------------------------------
	
	vecX = range(g)
	for i in range(g):
		vecX[i] = range(n)

	outFile = open(fileName , 'w')
	
	for j in range(n):
		# vertice (Ax , Ay)
		vecX[0][j] = data()
		vecX[0][j].fill(Ax,Ay,sigma)
		 
		# vertice (Bx , By)
		vecX[1][j] = data()
		vecX[1][j].fill(Bx , By,sigma)
		
		# vertice (Cx , Cy)
		vecX[2][j] = data()
		vecX[2][j].fill(Cx , Cy,sigma)
		
		# vertice (Dx , Dy)
		vecX[3][j] = data()
		vecX[3][j].fill(Dx , Dy,sigma)
		
		# vertice (Fx , Fy)
		vecX[4][j] = data()
		vecX[4][j].fill(Fx , Fy,sigma)
	
	### Scrive nella prima riga il numero di pattern (righe dopo le prime due)
	outFile.write(str(g*n)+'\n')
	### Scrive nella seconda riga il numeri di variabili (colonne)
	outFile.write(str(2)+'\n')
		
	for i in range(g):
		for j in range(n):	
			outFile.write(str(vecX[i][j].x)+'\t'+str(vecX[i][j].y)+'\n') 
		
	outFile.close()

def due(n,g):
	'''
	Crea un data set di due distribuzioni
	'''
	
	### Commentare se si e' scelto vertici manuali---------------
	
	Ax , Ay =  4,3	 
	Bx , By =  5,4	 
	 
	##-----------------------------------------------------------
	
	vecX = range(g)
	for i in range(g):
		vecX[i] = range(n)

	outFile = open(fileName , 'w')
	
	for j in range(n):
		# vertice (Ax , Ay)
		vecX[0][j] = data()
		vecX[0][j].fill(Ax,Ay,sigma)
		 
		# vertice (Bx , By)
		vecX[1][j] = data()
		vecX[1][j].fill(Bx , By,sigma)
	
	### Scrive nella prima riga il numero di pattern (righe dopo le prime due)
	outFile.write(str(g*n)+'\n')
	### Scrive nella seconda riga il numeri di variabili (colonne)
	outFile.write(str(2)+'\n')
		
	for i in range(g):
		for j in range(n):	
			outFile.write(str(vecX[i][j].x)+'\t'+str(vecX[i][j].y)+'\n') 
		
	outFile.close()
	
def NDimenioni():
	
	'''
	Crea un data set Ndimensionale
	d dimensioni, n dati per centro, g centri
	'''	
	
	
	### Matrice coordinate centri a manina
	#centri = NP.array([[Ax,Ay,Az],[Bx,By,Bz],[Cx,Cy,Cz],[Dx,Dy,Dz]])
	### ---- Preinpostati ---- 
	
	# 3D - 4Centri
	#~ centri = NP.array([[1,2,3],[4,3,2],[4,1,2],[2,1,3]])
	#~ d = 3
	#~ n = 30
	#~ g = 4
	
	# 5D - 4Centri
	#~ centri = NP.array([[1,2,3,4,5],[4,3,2,5,4],[4,1,2,5,4],[2,1,3,5,4]])
	#~ d = 5
	#~ n = 30
	#~ g = 4
	
	# 10D - 2Centri
	centri = NP.array([[1,2,3,4,5,6,7,8,9,10],[5,7,3,4,5,6,1,7,4,5]])
	d = 10
	n = 100
	g = 2

	#numero di dati in totale
	r = g * n

	a = NP.zeros((r,d))
	
	print centri 
	print ""

	k = 0
	f = 0

	for i in range(r):
		for j in range(d):
			
			a[i][j] = random.gauss(centri[k][j],sigma)
		
		print a[i]
		
		if(f < n-1):
			
			f += 1
		else:
			f=0
			k += 1

	outFile = open(fileName , 'w')
	
	### Scrive nella prima riga il numero di pattern (righe dopo le prime due)
	outFile.write(str(r)+'\n')
	### Scrive nella seconda riga il numeri di variabili (colonne)
	outFile.write(str(d)+'\n')
		
	for i in range(r):
		for j in range(d):	
		
			outFile.write(str(a[i][j])+'\t') 
		
		outFile.write('\n') 
		
	outFile.close()
	
def main():        
	
	if tipo == 1:
		### Numero di punti per vertice
		n = 30 
		### Numero di vertici      
		g = 4
		
		square(n,g)
		
	elif tipo == 2:
		### Numero di punti per vertice
		n = 30
		### Numero di vertici      
		g = 5
				
		pentagon(n,g)
	
	elif tipo == 3:
		### Numero di punti per vertice
		n = 100
		### Numero di vertici      
		g = 2
				
		due(n,g)
		
	elif tipo == 4:
				
		NDimenioni()
		
	else:
		"numero sbalgiato"
		exit(1)
		
if __name__ == "__main__":
	main()

